home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / lang_c / cug172 / ytab.c < prev    next >
C/C++ Source or Header  |  1986-02-05  |  25KB  |  887 lines
  1. /*
  2.   HEADER: CUG     nnn.nn;
  3.   TITLE:     LEX - A Lexical Analyser Generator
  4.   VERSION:     1.0 for IBM-PC
  5.   DATE:      Jan 30, 1985
  6.   DESCRIPTION:     A Lexical Analyser Generator. From UNIX
  7.   KEYWORDS:     Lexical Analyser Generator YACC C PREP
  8.   SYSTEM:     IBM-PC and Compatiables
  9.   FILENAME:      YTAB.C
  10.   WARNINGS:     This program is not for the casual user. It will
  11.          be useful primarily to expert developers.
  12.   CRC:         N/A
  13.   SEE-ALSO:     YACC and PREP
  14.   AUTHORS:     Scott Guthery 11100 leafwood lane Austin, TX 78750
  15.   COMPILERS:     DESMET-C
  16.   REFERENCES:     UNIX Systems Manuals
  17. */
  18. /*
  19.  *                   * * *   W A R N I N G    * * *
  20.  *
  21.  * This file has been hand-modified from that which was produced by Yacc
  22.  * from 'lex.y'. If you plan on rebuilding this with Yacc, be SURE to run
  23.  * the virgin supplied 'lex.y' thru Yacc first, do a source compare of it's
  24.  * output 'ytab.c' with this file, and note & understand the manual mods
  25.  * that were made here.
  26.  *                                              Bob Denny
  27.  *
  28.  * Modified 02-Dec-80 Bob Denny -- Conditionalized debug code for smaller size
  29.  *                                 YYSMALL no longer used.
  30.  *                                 Removed hackish accent grave's.
  31.  *                           01    Moved calls do dfa build, min, print and
  32.  *                                  write, and to stat() to lex.c, so this
  33.  *                                  module could be put in overlay region.
  34.  *                                  Moved impure data out into ytdata.c to
  35.  *                                  go to the root.
  36.  *
  37.  *          29-May-81 Bob Denny -- Define yysterm fwd. Remove from LEXLEX.H.
  38.  *                                   for RSX overlaying.
  39.  *          19-Mar-82 Bob Denny -- New compiler and library. Typcasts needed.
  40.  *                                  Conditionally compile remote formats, not
  41.  *                                  supported in VAX C.
  42.  * More     03-May-82 Bob Denny -- Final touches, remove unreferenced autos
  43.  * More        20-Nov-83 Scott Guthery -- Adapt for IBM PC & DeSmet C
  44.  */
  45.  
  46. #include <stdio.h>
  47. #include "ytab.h"
  48. #include "lexlex.h"
  49.  
  50. char *yysterm[] = {
  51. "error",
  52. "NAME",
  53. "CCLASS",
  54. "STRING",
  55. "CONCAT",
  56. 0 };
  57.  
  58. /* char copr[] = "Copyright (c) 1978 Charles H. Forsyth";*/
  59.  
  60. struct des {
  61.         struct nfa *d_start;
  62.         struct nfa *d_final;
  63. };
  64. extern struct nlist {                                           /* 01+ */
  65.         struct  nlist   *nl_next;
  66.         struct  nfa     *nl_base;
  67.         struct  nfa     *nl_end;
  68.         struct  nfa     *nl_start;
  69.         struct  nfa     *nl_final;
  70.         char    *nl_name;
  71. } *nlist;                                                       /* 01- */
  72.  
  73. extern  int     str_length;
  74. extern  struct  nfa     *elem();
  75. extern  struct  des     *newdp();
  76. extern  struct  nlist   *lookup();
  77. extern int yydebug; /* 1 for debugging */                       /* 01+ */
  78. extern int yychar; /* current input token number */
  79. extern int yynerrs ;  /* number of errors */
  80. extern int yyerrflag ;  /* error recovery flag */               /* 01- */
  81.  
  82. #define yyclearin yychar = -1
  83. #define yyerrok yyerrflag = 0
  84.  
  85. #ifndef YYSTYPE
  86. #define YYSTYPE int
  87.  
  88. #endif
  89. #ifndef YYVCOPY
  90. #define YYVCOPY(x,y)    (x)=(y)
  91. #endif
  92.  
  93. extern YYSTYPE yyval;                                           /* 01+ */
  94. extern YYSTYPE *yypv;
  95. extern YYSTYPE yylval;
  96.  
  97. # define YYMAXDEPTH 150
  98. extern YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  99.  
  100. extern int      nlook;
  101. extern int      yyline;
  102. extern char     *breakc;
  103. extern char     *ignore;
  104. extern char     *illeg;                                         /* 01- */
  105.  
  106. yyactr(__np__){
  107.  
  108.         struct nfa *np, *nbase;
  109.         char *cp;
  110.         struct des *dp;
  111.         struct trans *tp;
  112.         struct nlist *nl;
  113.         int i, c;
  114.  
  115. switch(__np__){
  116.  
  117. case 7:
  118. {
  119.                 dp = yypv[3];
  120.                 nl = yypv[1];
  121.                 np = nl->nl_base;
  122.                 nl->nl_start = dp->d_start;
  123.                 nl->nl_final = dp->d_final;
  124.                 nl->nl_end = nfap;
  125. #ifdef DEBUG
  126.                 fprintf(lexlog, "NFA (auxiliary definition) for %s\n",
  127.                                 nl->nl_name);
  128.                 nfaprint(dp->d_start, nl->nl_base);
  129. #endif
  130.                 nbase = lalloc(i = nl->nl_end-nl->nl_base, sizeof(*nbase),
  131.                         "nfa storage");
  132.                 copynfa(nl, nbase, dp);
  133.                 nl->nl_start = dp->d_start;
  134.                 nl->nl_final = dp->d_final;
  135.                 nl->nl_end = nbase+i;
  136.                 nl->nl_base = nbase;
  137.                 nfap = np;
  138.                 spccl(nl->nl_name, "ignore", dp, &ignore);
  139.                 spccl(nl->nl_name, "break", dp, &breakc);
  140.                 spccl(nl->nl_name, "illegal", dp, &illeg);
  141.         } break;
  142. case 8:
  143. { copycode(); } break;
  144. case 9:
  145. {
  146.                 yyval = lookup(yypv[1]);
  147.  
  148.                 ((struct nlist *)yyval)->nl_base = nfap;
  149.                 if (((struct nlist *)yyval)->nl_start)
  150.                         yyerror("%s redefined", ((struct nlist *)yyval)->nl_name);
  151.         } break;
  152. case 10:
  153. { yyval = lookup(yypv[1]); } break;
  154. case 11:
  155. {
  156.                 np = elem(CCL, yypv[1]);
  157.                 yyval = newdp(np, np->n_succ[0] = elem(FIN));
  158.         } break;
  159. case 12:
  160. {
  161.                 cp = yypv[1];
  162.                 if (str_length == 0) {
  163.                         np = elem(EPSILON);
  164.                         yyval = newdp(np, np->n_succ[0] = elem(FIN));
  165.                         return;
  166.                 }
  167.                 yyval = np = elem(*cp++);
  168.                 while (--str_length > 0)
  169.                         np = np->n_succ[0] = elem(*cp++);
  170.                 yyval = newdp(yyval, np->n_succ[0] = elem(FIN));
  171.         } break;
  172. case 13:
  173. {
  174.                 if ((nl = yypv[1])->nl_end == 0) {
  175.                         yyerror("%s not defined", nl->nl_name);
  176.                         nl->nl_base = nl->nl_end = elem(FIN);
  177.                         nl->nl_start = nl->nl_final = nl->nl_base;
  178.                 }
  179.                 yyval = dp = lalloc(1, sizeof(*dp), "dfa input");
  180.                 nbase = nfap;
  181.                 i = nl->nl_end-nl->nl_base;
  182.                 if ((nfap += i) >= &nfa[MAXNFA]) {
  183.                         yyerror("Out of NFA nodes", NULL);
  184.                         exit(1);
  185.                 }
  186.                 copynfa(nl, nbase, dp);
  187.         } break;
  188. case 14:
  189. {
  190.                 yyval = dp = yypv[1];
  191.                 dp->d_start = newnfa(EPSILON, np = dp->d_start, 0);
  192.                 dp->d_final->n_char = EPSILON;
  193.                 dp->d_final->n_succ[0] = np;
  194.                 dp->d_final->n_succ[1] = np = elem(FIN);
  195.                 dp->d_start->n_succ[1] = np;
  196.                 dp->d_final = np;
  197.  
  198.         } break;
  199. case 15:
  200. {
  201.                 yyval = dp = yypv[1];
  202.                 dp->d_start = newnfa(EPSILON, dp->d_start,
  203.                         ((struct des *)yypv[3])->d_start);
  204.                 dp->d_final->n_char = EPSILON;
  205.                 dp->d_final = dp->d_final->n_succ[0] = np = elem(FIN);
  206.                 dp = yypv[3];
  207.                 dp->d_final->n_char = EPSILON;
  208.                 dp->d_final->n_succ[0] = np;
  209.                 free(yypv[3]);
  210.         } break;
  211. case 16:
  212. {
  213.                 yyval = yypv[1];
  214.                 dp = yypv[2];
  215.                 np = ((struct des *)yyval)->d_final;
  216.                 ((struct des *)yyval)->d_final = dp->d_final;
  217.                 np->n_char = dp->d_start->n_char;
  218.                 np->n_ccl = dp->d_start->n_ccl;
  219.                 np->n_succ[0] = dp->d_start->n_succ[0];
  220.                 np->n_succ[1] = dp->d_start->n_succ[1];
  221.                 free(yypv[2]);
  222.         } break;
  223. case 17:
  224. { yyval = yypv[2]; } break;
  225. case 18:
  226. {
  227.                 ending();
  228.         trans1:
  229. #ifdef DEBUG
  230.                 fprintf(lexlog, "\nNFA for complete syntax\n");
  231.                 fprintf(lexlog, "state 0\n");
  232.                 for (tp = trans; tp < transp; tp++)
  233.                         fprintf(lexlog, "\tepsilon\t%d\n", tp->t_start-nfa);
  234.                 for (tp = trans; tp < transp; tp++)
  235.                         nfaprint(tp->t_start, nfa);
  236. #else
  237.                 ;
  238. #endif
  239.                                                                 /* 01 */
  240.         } break;
  241. case 19:
  242. { goto trans1; } break;
  243. case 22:
  244. {
  245.                 llactr();
  246.         } break;
  247. case 23:
  248. { dp = yypv[1];  newtrans(dp->d_start, dp->d_final); } break;
  249. case 24:
  250. { copycode(); } break;
  251. case 25:
  252.  
  253. {
  254.                 ending();
  255.                 while ((c = get()) != EOF)
  256.                         putc(c, llout);
  257.         } break;
  258. case 26:
  259. { action(); } break;
  260. case 27:
  261. {
  262.                 if (nlook >= NBPW)
  263.                         yyerror("More than %d translations with lookahead",
  264.                                         NBPW);
  265.                 yyval = dp = yypv[1];
  266.                 np = dp->d_final;
  267.                 np->n_char = EPSILON;
  268.                 np->n_flag |= LOOK;
  269.                 np->n_succ[0] = ((struct des *)yypv[3])->d_start;
  270.                 dp->d_final = ((struct des *)yypv[3])->d_final;
  271.                 np->n_look = nlook;
  272.                 dp->d_final->n_look = nlook++;
  273.                 dp->d_final->n_flag |= FLOOK;
  274.                 free(yypv[3]);
  275.         } break;
  276. }
  277. }
  278. int yyerrval = 256;
  279.  
  280. /*
  281.  * Lexical analyser
  282.  * (it isn't done with lex...)
  283.  */
  284. extern char     buffer[150];                                    /* 01 */
  285.  
  286. yylex()
  287. {
  288.         register c;
  289.         register char *cp;
  290.         int lno;
  291.  
  292.         if (yyline == 0)
  293.                 yyline++;
  294. loop:
  295.         c = get();
  296.         if (isupper(c)) {
  297.                 name(c);
  298.                 for (cp = yylval; c = *cp; cp++)
  299.                         if (isupper(c))
  300.                                 *cp = tolower(c);
  301.                 return(STRING);
  302.         } else if (islower(c) || c == '_') {
  303.                 name(c);
  304.                 return(NAME);
  305.  
  306.         }
  307.         switch (c) {
  308.         case -1 /*EOF*/:
  309.                 return(0);
  310.  
  311.         case '[':
  312.                 return(cclass());
  313.  
  314.         case '(':
  315.         case ')':
  316.         case '{':
  317.         case '}':
  318.         case '*':
  319.         case '|':
  320.         case '=':
  321.         case ';':
  322.         case '%':
  323.                 return(c);
  324.  
  325.         case '/':
  326.                 if ((c = get()) != '*') {
  327.                         unget(c);
  328.                         return('/');
  329.                 }
  330.                 lno = yyline;
  331.                 for (; c != EOF; c = get())
  332.                         if (c == '*')
  333.                                 if ((c = get()) == '/')
  334.                                         goto loop; else
  335.                                         unget(c);
  336.                 yyline = lno;
  337.                 yyerror("End of file in comment", NULL);
  338.  
  339.         case '\'':
  340.         case '"':
  341.                 yylval = buffer;
  342.                 string(c);
  343.                 return(STRING);
  344.  
  345.         case '\n':
  346.         case '\r':
  347.         case ' ':
  348.         case '\t':
  349.                 goto loop;
  350.  
  351.         default:
  352.                 yylval = buffer;
  353.                 buffer[0] = c;
  354.                 buffer[1] = 0;
  355.                 str_length = 1;
  356.                 return(STRING);
  357.         }
  358. }
  359.  
  360. extern char     ccl[(NCHARS+1)/NBPC];                           /* 01 */
  361.  
  362. cclass()
  363. {
  364.         register c, i, lc;
  365.         int compl;
  366.  
  367.         compl = 0;
  368.         for (i = 0; i < sizeof ccl; i++)
  369.  
  370.                 ccl[i] = 0;
  371.         if ((c = get()) == '^')
  372.                 compl++; else
  373.                 unget(c);
  374.         lc = -1;
  375.         while ((c = mapc(']')) != EOF) {
  376.                 if (c == '-' && lc >= 0) {
  377.                         if ((c = mapc(']')) == EOF)
  378.                                 break;
  379.                         for (i = lc; i <= c; i++)
  380.                                 ccl[i/NBPC] |= 1<<(i%NBPC);
  381.                         lc = -1;
  382.                         continue;
  383.                 }
  384.                 ccl[c/NBPC] |= 1<<(c%NBPC);
  385.                 lc = c;
  386.         }
  387.         if (compl) {
  388.                 for (i = 0; i < sizeof ccl; i++)
  389.                         ccl[i] ^= -1;
  390.                 if (aflag == 0)
  391.                         for (i = 0200; i < (1<<NBPC); i++)
  392.                                 ccl[i/NBPC] &= ~(1 << (i%NBPC));
  393.         }
  394.         yylval = newccl(ccl);
  395.         return(CCLASS);
  396. }
  397.  
  398. string(ec)
  399. {
  400.         register char *cp;
  401.         register c;
  402.  
  403.         for (cp = buffer; (c = mapc(ec)) != EOF;)
  404.                 *cp++ = c;
  405.         *cp = 0;
  406.         str_length = cp-buffer;
  407. }
  408.  
  409. mapc(ec)
  410. {
  411.         register c, v, i;
  412.  
  413.         if ((c = get()) == ec)
  414.                 return(EOF);
  415.         switch(c) {
  416.         case -1 /*EOF*/:
  417.                 yyerror("End of file in string", NULL);
  418.                 return(c);
  419.  
  420.         case '\\':
  421.                 if ((c = get()) >= '0' && c <= '7') {
  422.                         i = 0;
  423.                         for (v = 0; c>='0' && c<='7' && i++<3; c = get())
  424.                                 v = v*010 + c-'0';
  425.                         unget(c);
  426.                         return(v&0377);
  427.                 }
  428.                 switch (c) {
  429.                 case 'n':
  430.                         return('\n');
  431.                 case 't':
  432.                         return('\t');
  433.  
  434.                 case 'b':
  435.                         return('\b');
  436.  
  437.                 case 'r':
  438.                         return('\r');
  439.  
  440.                 case '\n':
  441.                         yyline++;
  442.                         return(mapc(ec));
  443.                 }
  444.  
  445.         default:
  446.                 return(c);
  447.         }
  448. }
  449.  
  450. name(c)
  451. register c;
  452. {
  453.         register char *cp;
  454.  
  455.         for (yylval=cp=buffer; isalpha(c) || isdigit(c) || c=='_'; c=get())
  456.                 *cp++ = c;
  457.         *cp = 0;
  458.         str_length = cp-buffer;
  459.         unget(c);
  460. }
  461.  
  462. /*
  463.  * Miscellaneous functions
  464.  * used only by lex.y
  465.  */
  466. struct nfa *
  467. elem(k, v)
  468. {
  469.         struct nfa *fp;
  470.  
  471.         fp = newnfa(k, 0, 0);
  472.         if (k == CCL)
  473.                 fp->n_ccl = v;
  474.         return(fp);
  475. }
  476.  
  477. struct des *
  478. newdp(st, fi)
  479. struct nfa *st, *fi;
  480. {
  481.         register struct des *dp;
  482.  
  483.         dp = lalloc(1, sizeof(*dp), "dfa input");
  484.         dp->d_start = st;
  485.         dp->d_final = fi;
  486.         return(dp);
  487. }
  488.  
  489. action()
  490. {
  491.         register c;
  492.         int lno, lev;
  493.  
  494.         newcase(transp-trans);
  495.         lno = yyline;
  496.         lev = 0;
  497.         for (; (c = get()) != EOF && (c != '}' || lev); putc(c, llout))
  498.                 if (c == '{')
  499.                         lev++;
  500.                 else if (c == '}')
  501.                         lev--;
  502.                 else if (c == '\'' || c == '"') {
  503.                         putc(c, llout);
  504.                         skipstr(c);
  505.                 }
  506.         fprintf(llout, "\n         break;\n");
  507.         if (c == EOF) {
  508.                 yyline = lno;
  509.                 yyerror("End of file in action", NULL);
  510.         }
  511. }
  512.  
  513. skipstr(ec)
  514. register ec;
  515. {
  516.         register c;
  517.  
  518.         while ((c = get()) != ec && c != EOF) {
  519.                 putc(c, llout);
  520.                 if (c == '\\' && (c = get()) != EOF)
  521.                         putc(c, llout);
  522.         }
  523. }
  524.  
  525. copycode()
  526. {
  527.         int lno;
  528.         register c;
  529.  
  530.         setline();
  531.         lno = yyline;
  532.         for (; (c = get()) != EOF; putc(c, llout))
  533.                 if (c == '%') {
  534.                         if ((c = get()) == '}')
  535.                                 return;
  536.                         unget(c);
  537.                         c = '%';
  538.                 }
  539.         yyline = lno;
  540.         yyerror("Incomplete %{ declaration", NULL);
  541.         exit(1);
  542. }
  543.  
  544. struct nlist *
  545. lookup(s)
  546. register char *s;
  547. {
  548.         register struct nlist *nl;
  549.         register char *cp;
  550.         int i;
  551.         for (nl = nlist; nl; nl = nl->nl_next)
  552.                 if (!strcmp(s, nl->nl_name))
  553.                         return(nl);
  554.  
  555.         nl = lalloc(1, sizeof(*nl), "namelist");
  556.         nl->nl_start = nl->nl_end = nl->nl_base = nl->nl_end = 0;
  557.         nl->nl_next = nlist;
  558.         nlist = nl;
  559.         i = 0;
  560.         nl->nl_name = cp = lalloc(strlen(s) + 1, sizeof(*cp), "namelist");
  561.         strcpy(cp, s);
  562.         return(nl);
  563. }
  564.  
  565. copynfa(nl, nbase, dp)
  566. struct nlist *nl;
  567. struct des *dp;
  568. struct nfa *nbase;
  569. {
  570.         register struct nfa *np, *ob;
  571.         register j;
  572.         int i;
  573.  
  574.         ob = nl->nl_base;
  575.         i = nl->nl_end-ob;
  576.         copy(nbase, ob, sizeof(*np) * i);
  577.         for (np = nbase; i-- > 0; np++) {
  578.                 np->n_flag &= ~NPRT;
  579.                 for (j = 0; j < 2; j++)
  580.                         if (np->n_succ[j])
  581.                                 np->n_succ[j] = (np->n_succ[j]-ob)+nbase;
  582.         }
  583.         dp->d_start = (nl->nl_start-ob)+nbase;
  584.         dp->d_final = (nl->nl_final-ob)+nbase;
  585. }
  586.  
  587. copy(out, in, count)
  588. register char   *out;
  589. register char   *in;
  590. register int    count;
  591. {
  592.         while (--count >= 0)
  593.                 *out++ = *in++;
  594. }
  595.  
  596. spccl(nm, isit, dp, where)
  597. char                    *nm;
  598. char                    *isit;
  599. register struct des     *dp;
  600. char                    **where;
  601. {
  602.  
  603.         if (!strcmp(nm, isit)) {
  604.                 if (*where != 0)
  605.                         yyerror("Redefinition of %s class", isit);
  606.                 if (dp->d_start->n_char == CCL &&
  607.                                 dp->d_start->n_succ[0] == dp->d_final)
  608.                         *where = dp->d_start->n_ccl;
  609.                 else
  610.                         yyerror("Illegal %s class", isit);
  611.         }
  612. }
  613.  
  614. get()
  615. {
  616.         register int c;
  617.  
  618.         if ((c = getc(lexin)) == '\n')
  619.                 yyline++;
  620.         return(c);
  621. }
  622.  
  623. unget(c)
  624. register c;
  625. {
  626.         if (c == '\n')
  627.                 yyline--;
  628.         ungetc(c, lexin);
  629. }
  630.  
  631. yyerror(format, value)
  632. char *format, *value;
  633. {
  634.         char buffer[50];
  635.         if (yyline)
  636.                 fprintf(stderr, "%d: ", yyline);
  637.         fprintf(stderr, format, value);
  638.         if (yychar > 256)
  639.                 fprintf(stderr, " near '%s'", yysterm[yychar-256]);
  640.         else if (yychar < 256 && yychar > 0)
  641.                 fprintf(stderr, " near '%c'", yychar);
  642.         fprintf(stderr, "\n");
  643. }
  644.  
  645. int nterms = 15;
  646. int nnonter = 13;
  647. int nstate = 41;
  648.  
  649. char *yysnter[14] = {
  650. "$accept",
  651. "lexfile",
  652. "auxiliary_section",
  653. "translation_section",
  654. "auxiliaries",
  655. "auxiliary",
  656. "namedef",
  657. "regexp",
  658. "name",
  659. "translations",
  660. "translation",
  661. "llactr",
  662. "pattern",
  663. "action" };
  664.  
  665. int yylast = 245;
  666. yyexcp(s)
  667. int s;
  668. {
  669.         switch(s){
  670.         case 1:
  671.                 if( yychar == 0 ) return( -1 );
  672.                 return( 0 );
  673.         case 2:
  674.                 if( yychar == 0 ) return( 19 );
  675.                 return( 22 );
  676.                 }
  677.         }
  678.  
  679. yyact[] = {
  680.  
  681.   23,  40,  32,  23,  29,  32,  23,  15,  32,  23,
  682.   31,  32,  23,  35,  32,  18,  26,  13,  23,  32,
  683.   34,  23,  37,  11,   4,   5,  16,  28,  17,  12,
  684.   19,  19,  10,   9,  22,   6,  27,  25,   3,   8,
  685.    2,   1,   0,   0,  36,   0,   0,   0,   0,   0,
  686.    0,   0,   0,   0,  38,   0,  39,   0,   0,   0,
  687.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  688.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  689.    0,   0,   0,   0,  33,   0,   0,  33,   0,   0,
  690.   33,   0,   0,  33,   0,   0,  30,   0,   0,   0,
  691.    0,   0,  14,  14,   0,   0,   0,   0,   0,   0,
  692.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  693.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  694.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  695.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  696.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  697.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  698.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  699.  
  700.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  701.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  702.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  703.    0,   0,   0,   0,   0,   0,   0,  24,  20,  21,
  704.   24,  20,  21,  24,  20,  21,  24,  20,  21,  24,
  705.   20,  21,   0,   0,   0,  24,  20,  21,  24,  20,
  706.   21,   0,   0,   7,   7 };
  707. yypact[] = {
  708.  
  709.  -13,-2000,-2000, -14, -20,-1000, -54,-1000,-1000, -22,
  710.  -22, -21,-1000,-1000,-1000, -19,-1000,-119, -27, -34,
  711. -1000,-1000,-1000, -19,-1000,-1000,-1000, -37,-1000,-1000,
  712. -1000,-1000,-1000, -19, -23, -19, -40,-1000, -28, -31,
  713. -1000 };
  714. yypgo[] = {
  715.  
  716.    0,  41,  40,  39,  38,  25,  35,  20,  34,  33,
  717.   26,  32,  28,  27 };
  718. yyr1[] = {
  719.  
  720.    0,   1,   1,   2,   2,   4,   4,   5,   5,   6,
  721.    8,   7,   7,   7,   7,   7,   7,   7,   3,   3,
  722.    9,   9,  11,  10,  10,  10,  13,  12,  12,  -1 };
  723. yyr2[] = {
  724.  
  725.    0,   2,   0,   3,   2,   2,   1,   4,   2,   1,
  726.    1,   1,   1,   1,   2,   3,   2,   3,   1,   0,
  727.    2,   2,   0,   2,   2,   2,   1,   3,   1,  -1 };
  728. yychk[] = {
  729.  
  730.    0,  -1,  -2,  -4,  37,  -5,  -6, 257,  -3,  -9,
  731.  -11,  37,  -5,  37, 123,  61, -10, -12,  37,  -7,
  732.  258, 259,  -8,  40, 257, -10,  37,  -7, -13, 123,
  733.  123,  37,  42, 124,  -7,  47,  -7,  59,  -7,  -7,
  734.   41 };
  735. yydef[] = {
  736.  
  737.    2,  -2,  -2,   0,   0,   6,   0,   9,   1,  18,
  738.    0,   0,   5,   4,   8,   0,  20,   0,   0,  28,
  739.   11,  12,  13,   0,  10,  21,   3,   0,  23,  26,
  740.   24,  25,  14,   0,  16,   0,   0,   7,  15,  27,
  741.   17 };
  742.  
  743. # define YYFLAG1 -1000
  744. # define YYFLAG2 -2000
  745.  
  746. /* test me on cases where there are more than one reduction
  747. per state, leading to the necessity to look ahead, and other
  748. arcane flows of control.
  749. */
  750.  
  751. /*      parser for yacc output  */
  752. /* extern YYSTYPE yyval;        -- defined in the table file
  753.  * extern YYSTYPE yylval;       -- defined in the table file
  754.  * extern YYSTYPE *yypv;        -- defined in the table file
  755.  */
  756.  
  757. #ifdef  DEBUG
  758. #define LOGOUT  lexlog
  759. #endif
  760.  
  761. yyparse() {
  762.    int yys[YYMAXDEPTH];
  763.    int yyj;
  764.    register yyn, yystate, *yyps;
  765.  
  766.    yystate = 0;
  767.    yychar = -1;
  768.    yynerrs = 0;
  769.    yyerrflag = 0;
  770.    yyps= &yys[0]-1;
  771.    yypv= &yyv[0]-1;
  772.  
  773.  yystack:    /* put a state and value onto the stack */
  774.  
  775. #ifdef DEBUG
  776.    if( yydebug  )
  777.         fprintf(LOGOUT, "state %d, value %d, char %d\n",yystate,yyval,yychar);
  778. #endif
  779.  
  780.    *++yyps = yystate;
  781.    *++yypv = yyval;
  782.  
  783.  yynewstate:
  784.  
  785.    yyn = yypact[yystate];
  786.  
  787.    if( yyn<= YYFLAG1 ){ /* simple state */
  788.       if( yyn == YYFLAG2 && yychar<0 ) yychar = yylex();
  789.       goto yydefault;
  790.       }
  791.  
  792.    if( yychar<0 ) yychar = yylex();
  793.    if( (yyn += yychar)<0 || yyn >= yylast ) goto yydefault;
  794.  
  795.    if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  796.       yychar = -1;
  797.       yyval = yylval;
  798.       yystate = yyn;
  799.       if( yyerrflag > 0 ) --yyerrflag;
  800.       goto yystack;
  801.       }
  802.  
  803.  yydefault:
  804.    /* default state action */
  805.  
  806.    if( (yyn=yydef[yystate]) == -2 ) yyn = yyexcp( yystate );
  807.  
  808.   if( yyn == -1 ){ /* accept */
  809.       return( 0 );
  810.  
  811.       }
  812.  
  813.    if( yyn == 0 ){ /* error */
  814.       /* error ... attempt to resume parsing */
  815.  
  816.       switch( yyerrflag ){
  817.  
  818.       case 0:   /* brand new error */
  819.  
  820.          ++yynerrs;
  821.          yyerror("syntax error", NULL);
  822.  
  823.       case 1:
  824.       case 2: /* incompletely recovered error ... try again */
  825.  
  826.          yyerrflag = 3;
  827.  
  828.          /* find a state where "error" is a legal shift action */
  829.  
  830.          while ( yyps >= yys ) {
  831.             yyn = yypact[*yyps] + yyerrval;
  832.             if( yyn>= 0 && yyn < yylast && yychk[yyact[yyn]] == yyerrval ){
  833.                yystate = yyact[yyn];  /* simulate a shift of "error" */
  834.                goto yystack;
  835.                }
  836.             yyn = yypact[*yyps];
  837.  
  838.             /* the current yyps has no shift onn "error", pop stack */
  839.  
  840. #ifdef DEBUG
  841.             if(yydebug)
  842.                 fprintf(LOGOUT, "error recovery pops state %d, uncovers %d\n",
  843.                         *yyps, yyps[-1]);
  844. #endif
  845.             --yyps;
  846.             --yypv;
  847.             }
  848.  
  849.          /* there is no state on the stack with an error shift ... abort */
  850.  
  851.     abort:
  852.          return(1);
  853.  
  854.       case 3:  /* no shift yet; clobber input char */
  855.  
  856. #ifdef DEBUG
  857.          if (yydebug)
  858.                 fprintf(LOGOUT, "error recovery discards char %d\n", yychar );
  859. #endif
  860.  
  861.          if( yychar == 0 ) goto abort; /* don't discard EOF, quit */
  862.          yychar = -1;
  863.          goto yynewstate;   /* try again in the same state */
  864.  
  865.          }
  866.  
  867.       }
  868.  
  869.    /* reduction by production yyn */
  870.  
  871. #ifdef DEBUG
  872.       if(yydebug) fprintf(LOGOUT, "reduce %d\n",yyn);
  873. #endif
  874.  
  875.       yyps -= yyr2[yyn];
  876.       yypv -= yyr2[yyn];
  877. /*    YYVCOPY(yyval,yypv[1]);
  878.  */   yyval = yypv[1];
  879.       yyactr(yyn);
  880.          /* consult goto table to find next state */
  881.       yyn = yyr1[yyn];
  882.       yyj = yypgo[yyn] + *yyps + 1;
  883.       if( yyj>=yylast || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  884.       goto yystack;  /* stack new state and value */
  885.  
  886.    }
  887.